// 引入API工具
const api = require('../../utils/api.js');
const storage = require('../../utils/storage.js');
const permission = require('../../utils/permission.js'); // 🎯 引入权限工具
const imageUtil = require('../../utils/image.js');
const level = require('../../utils/level.js'); // 🎯 引入等级工具

Page({
  data: {
    statusBarHeight: 0,
    activityId: null,
    activity: null,
    loading: true,
    error: null,
    joining: false, // 🔥 防止重复点击
    // 🔥 当前用户是否已实名认证（用于控制地址显示）
    isCurrentUserVerified: false
  },

  onLoad(options) {
    console.log('🎯 =============== 活动详情页加载 ===============');
    console.log('📦 接收到的参数:', options);

    const windowInfo = wx.getWindowInfo();
    
    // 🔥 统一处理多种参数名（支持 id 或 activityId）
    const activityId = options.id || options.activityId;
    
    if (activityId) {
      console.log('✅ 获取到活动ID:', activityId);
      this.setData({
        statusBarHeight: windowInfo.statusBarHeight,
        activityId: activityId
      });
      
      // 🔥 加载真实活动详情
      this.loadActivityDetail(parseInt(activityId));
      
      // 🎯 初始化权限系统（模仿Flutter项目）
      if (userInfo && userInfo.userPoints) {
        permission.accordingToUserPointsForPermission(userInfo.userPoints);
        console.log('✅ 权限系统初始化完成，用户积分:', userInfo.userPoints);
      }
    } else {
      console.error('❌ 缺少活动ID参数，接收到的参数:', options);
      this.setData({
        statusBarHeight: windowInfo.statusBarHeight,
        loading: false,
        error: '缺少活动ID参数'
      });
      
      wx.showToast({
        title: '缺少活动ID',
        icon: 'none'
      });
    }
  },

  onShow() {
    // 🔔 自动初始化通知组件
    const app = getApp();
    app.autoInitNotification();
  },

  // 🔥 加载活动详情（对接真实API）
  loadActivityDetail(activityId) {
    console.log('📡 开始加载活动详情，ID:', activityId);

    this.setData({ loading: true });
    
    // 🔥 检查当前用户的实名认证状态
    this.checkCurrentUserVerification();

    api.getActivityDetail(activityId)
      .then(response => {
        console.log('✅ 活动详情加载成功:', response);

        if (response.status === 'success' && response.activity) {
          // 🎨 格式化活动数据
          const activity = this.formatActivityData(response.activity, response.user);
          
          this.setData({
            activity: activity,
            loading: false,
            error: null
          });

          console.log('✅ 活动数据已设置到页面:', activity);
        } else {
          throw new Error(response.message || '活动详情加载失败');
        }
      })
      .catch(error => {
        console.error('❌ 活动详情加载失败:', error);
        this.setData({
          loading: false,
          error: error.message || '加载失败，请重试'
        });

        wx.showToast({
          title: '加载失败',
          icon: 'none'
        });
      });
  },

  // 🔥 检查当前用户的实名认证状态（用于控制地址显示）
  checkCurrentUserVerification() {
    console.log('🔍 检查当前用户实名认证状态（地址显示控制）...');
    
    const userInfo = storage.getUserInfo();
    
    if (!userInfo) {
      console.log('❌ 用户未登录，地址不可见');
      this.setData({ isCurrentUserVerified: false });
      return;
    }
    
    const realNameAuth = userInfo.extraData?.realNameAuth;
    const isVerified = realNameAuth?.verified === true;
    
    console.log('📋 当前用户实名认证状态:', {
      hasRealNameAuth: !!realNameAuth,
      verified: isVerified,
      name: realNameAuth?.name || '未设置'
    });
    
    this.setData({ isCurrentUserVerified: isVerified });
    
    if (isVerified) {
      console.log('✅ 当前用户已实名认证，地址可见');
    } else {
      console.log('⚠️ 当前用户未实名认证，地址不可见');
    }
  },

  // 🎨 格式化活动数据（将API返回的数据转换为页面需要的格式）
  formatActivityData(activityData, userData) {
    console.log('🎨 格式化活动数据...');
    console.log('📊 原始活动数据:', activityData);
    console.log('👤 发布者数据:', userData);
    console.log('🔍 调试 publisherId:');
    console.log('   - activityData.publisherId:', activityData.publisherId);
    console.log('   - userData?.userid:', userData?.userid);

    // 🔥 处理活动图片（确保是数组格式）
    let images = [];
    if (activityData.activityImages) {
      if (Array.isArray(activityData.activityImages)) {
        images = activityData.activityImages;
      } else if (typeof activityData.activityImages === 'string') {
        try {
          images = JSON.parse(activityData.activityImages);
        } catch (e) {
          images = [activityData.activityImages];
        }
      }
    }
    // 🔥 使用图片工具类处理图片URL（自动HTTP转HTTPS，真机要求）
    images = imageUtil.processActivityImages(images);

    // 🔥 处理活动类型（确保是数组格式）
    let activityType = [];
    if (activityData.activityType) {
      if (Array.isArray(activityData.activityType)) {
        activityType = activityData.activityType;
      } else if (typeof activityData.activityType === 'string') {
        try {
          activityType = JSON.parse(activityData.activityType);
        } catch (e) {
          activityType = [activityData.activityType];
        }
      }
    }

    // 🔥 格式化时间（从ISO格式转换为易读格式）
    const formatTime = (isoTime) => {
      if (!isoTime) return '时间待定';
      try {
        // ISO时间格式: "2025-08-15T09:00:00" 或 "2025-10-18 18:42"
        if (isoTime.includes('T')) {
          // ISO格式：将T替换为空格
          return isoTime.replace('T', ' ').substring(0, 19);
        } else {
          // 已经是标准格式，直接返回
          return isoTime;
        }
      } catch (e) {
        return isoTime;
      }
    };

    // 🔥 解析性别限制
    let genderLimit = '无限制';
    if (activityData.activityRestriction) {
      let restrictions = [];
      if (Array.isArray(activityData.activityRestriction)) {
        restrictions = activityData.activityRestriction;
      } else if (typeof activityData.activityRestriction === 'string') {
        try {
          restrictions = JSON.parse(activityData.activityRestriction);
        } catch (e) {
          restrictions = [activityData.activityRestriction];
        }
      }
      if (restrictions.length > 0) {
        genderLimit = restrictions.join(', ');
      }
    }

    // 🔥 解析 extraData（可能是JSON字符串或对象）
    let extraDataObj = null;
    if (activityData.extraData) {
      if (typeof activityData.extraData === 'string') {
        // extraData 是字符串，需要解析
        try {
          extraDataObj = JSON.parse(activityData.extraData);
          console.log('✅ extraData 从字符串解析成功:', extraDataObj);
        } catch (e) {
          console.error('❌ extraData JSON解析失败:', e);
          extraDataObj = null;
        }
      } else if (typeof activityData.extraData === 'object') {
        // extraData 已经是对象
        extraDataObj = activityData.extraData;
        console.log('✅ extraData 已经是对象:', extraDataObj);
      }
    }

    // 🔥 获取活动结束时间（优先从extraData中获取，否则使用开始时间+2小时）
    console.log('🔍 =============== 调试结束时间获取 ===============');
    console.log('🔍 extraDataObj 存在吗?', !!extraDataObj);
    console.log('🔍 extraDataObj 内容:', extraDataObj);
    console.log('🔍 activityEndTime 值:', extraDataObj?.activityEndTime);
    
    let endTime;
    if (extraDataObj && extraDataObj.activityEndTime) {
      // 从extraData获取真实的结束时间
      endTime = formatTime(extraDataObj.activityEndTime);
      console.log('✅ 使用真实结束时间:', extraDataObj.activityEndTime, '→ 格式化后:', endTime);
    } else {
      // 兜底：使用开始时间（后续可以在UI层面计算+2小时）
      endTime = formatTime(activityData.activityPublishTime);
      console.log('⚠️ 未找到结束时间，使用开始时间:', activityData.activityPublishTime, '→ 格式化后:', endTime);
    }
    console.log('🔍 =============== 结束时间获取完成 ===============');

    // 🔥 使用等级工具类计算发布者等级
    const publisherPoints = userData?.userPoints || activityData.publisherPoints || 0;
    const levelName = level.getLevelNameFromPoints(publisherPoints);
    console.log('🏆 发布者积分:', publisherPoints, '→ 等级:', levelName);

    // 🔥 使用图片工具类处理头像URL（自动HTTP转HTTPS，真机要求）
    const authorAvatar = imageUtil.processAvatar(
      userData?.userAvatarUrl || activityData.publisherAvatar || 'https://bai-ying.oss-cn-qingdao.aliyuncs.com/image/user_test/user_2.webp'
    );

    // 🎨 组装格式化后的活动对象
    const formattedActivity = {
      id: activityData.activityId,
      images: images.length > 0 ? images : ['https://bai-ying.oss-cn-qingdao.aliyuncs.com/image/post/21.jpg'], // 默认图片
      currentImageIndex: 0,
      title: activityData.activityTitle || '活动标题',
      location: activityData.activityLocation || '地点待定',
      startTime: formatTime(activityData.activityPublishTime),
      endTime: endTime, // 🔥 使用真实的结束时间
      author: userData?.username || activityData.publisherNickname || '未知用户',
      authorAvatar: authorAvatar, // 🔥 使用处理后的HTTPS头像URL
      gender: userData?.userGender || activityData.publisherGender || 'male',
      level: levelName, // 🔥 使用根据积分计算的等级名称
      participants: activityData.activityCurrentParticipants || 0,
      maxParticipants: activityData.activityMaxParticipants || 10,
      cost: activityType.join(', ') || '待商议',
      genderLimit: genderLimit,
      description: activityData.activityDetails || '暂无详细描述',
      distance: `${(activityData.distance || 0).toFixed(1)}公里`,
      // 🔥 额外的原始数据（用于后续扩展）
      rawData: {
        activityTags: activityData.activityTags,
        activityStatus: activityData.activityStatus,
        publisherId: activityData.publisherId || userData?.userid, // 🔥 优先使用 activity.publisherId，兜底使用 user.userid
        latitude: activityData.latitude,
        longitude: activityData.longitude,
        extraData: extraDataObj || activityData.extraData // 🔥 使用解析后的对象
      }
    };

    console.log('✅ 格式化后的活动数据:', formattedActivity);
    return formattedActivity;
  },

  // 返回
  goBack() {
    console.log('🔙 =============== 点击返回按钮 ===============');
    
    // 🔥 获取当前页面栈
    const pages = getCurrentPages();
    console.log('📚 页面栈长度:', pages.length);
    
    // 🔥 如果页面栈长度大于1，说明有上一页，可以返回
    if (pages.length > 1) {
      console.log('✅ 有上一页，执行返回操作');
      wx.navigateBack({
        fail: (err) => {
          console.error('❌ 返回失败:', err);
          // 返回失败时跳转到主页
          this.goToHome();
        }
      });
    } else {
      // 🔥 页面栈只有一个页面（通常是从分享链接进入），跳转到主页
      console.log('⚠️ 页面栈只有一个页面，从分享进入，跳转到主页');
      this.goToHome();
    }
  },
  
  // 🔥 跳转到主页
  goToHome() {
    console.log('🏠 跳转到主页');
    wx.switchTab({
      url: '/pages/main/index',
      fail: (err) => {
        console.error('❌ switchTab失败:', err);
        // switchTab失败时使用reLaunch
        wx.reLaunch({
          url: '/pages/main/index'
        });
      }
    });
  },

  // 图片滑动切换
  onImageChange(e) {
    const imageIndex = e.detail.current;
    this.setData({
      'activity.currentImageIndex': imageIndex
    });
  },

  // 守护者
  onLevel() {
    wx.showToast({
      title: '等级功能',
      icon: 'none'
    });
  },

  /**
   * 🔥 查看用户主页（点击头像/昵称区域）
   */
  onViewUserProfile() {
    console.log('👤 =============== 查看用户主页 ===============');
    
    const activity = this.data.activity;
    const currentUser = storage.getUserInfo();
    
    if (!activity || !activity.rawData || !activity.rawData.publisherId) {
      wx.showToast({
        title: '无法获取用户信息',
        icon: 'none'
      });
      return;
    }
    
    const publisherId = activity.rawData.publisherId;
    const currentUserId = currentUser ? currentUser.userid : null;
    
    console.log('🎯 发布者ID:', publisherId);
    console.log('👤 当前用户ID:', currentUserId);
    
    // 🔥 跳转到用户主页（传递userId参数）
    // 用户主页会自动判断：
    // - 如果userId === 当前用户ID → 调用getUserContent接口（查看自己）
    // - 如果userId !== 当前用户ID → 调用getUserFilteredContent接口（查看他人）
    wx.navigateTo({
      url: `/pages/user-info/index?userId=${publisherId}`
    });
    
    console.log('✅ 跳转到用户主页，传递参数: userId=' + publisherId);
  },

  // 🗺️ 查看地图 - 显示选择菜单
  viewMap() {
    // 🔥 检查当前用户是否已实名认证
    if (!this.data.isCurrentUserVerified) {
      wx.showModal({
        title: '实名认证提示',
        content: '查看活动地址需要先完成实名认证，是否前往认证？',
        confirmText: '去认证',
        cancelText: '取消',
        confirmColor: '#D84545',
        success: (res) => {
          if (res.confirm) {
            wx.navigateTo({
              url: '/pages/verify/index'
            });
          }
        }
      });
      return;
    }

    const { activity } = this.data;
    if (!activity || !activity.location) {
      wx.showToast({
        title: '位置信息不完整',
        icon: 'none'
      });
      return;
    }

    // 检查是否有经纬度信息
    const hasCoordinates = activity.rawData && activity.rawData.latitude && activity.rawData.longitude;
    
    if (!hasCoordinates) {
      wx.showToast({
        title: '位置坐标信息不完整',
        icon: 'none'
      });
      return;
    }

    // 显示选择菜单
    wx.showActionSheet({
      itemList: ['查看地图', '导航到这里'],
      success: (res) => {
        if (res.tapIndex === 0) {
          // 查看地图：跳转到小程序内部地图页面
          this.openInternalMap();
        } else if (res.tapIndex === 1) {
          // 导航到这里：打开微信内置地图（支持跳转到高德/百度地图APP）
          this.openExternalNavigation();
        }
      }
    });
  },

  // 🗺️ 打开小程序内部地图页面
  openInternalMap() {
    const { activity } = this.data;
    wx.navigateTo({
      url: `/pages/map/index?location=${encodeURIComponent(activity.location)}&latitude=${activity.rawData.latitude || ''}&longitude=${activity.rawData.longitude || ''}`
    });
  },

  // 🗺️ 打开微信内置地图导航（支持跳转到高德/百度地图APP）
  openExternalNavigation() {
    const { activity } = this.data;
    
    console.log('🗺️ =============== 打开外部导航 ===============');
    console.log('📍 位置名称:', activity.location);
    console.log('📍 纬度:', activity.rawData.latitude);
    console.log('📍 经度:', activity.rawData.longitude);
    
    wx.openLocation({
      latitude: parseFloat(activity.rawData.latitude),
      longitude: parseFloat(activity.rawData.longitude),
      name: activity.title || '活动地点',
      address: activity.location,
      scale: 16, // 缩放级别，范围5-18，默认18
      success: () => {
        console.log('✅ 地图导航打开成功');
      },
      fail: (error) => {
        console.error('❌ 地图导航打开失败:', error);
        wx.showToast({
          title: '打开地图失败',
          icon: 'none'
        });
      }
    });
  },


  /**
   * 🔥 点击分享按钮（手动触发分享）
   */
  onShare() {
    wx.showShareMenu({
      withShareTicket: true,
      menus: ['shareAppMessage', 'shareTimeline']
    });
    
    // 提示用户点击右上角分享
    wx.showToast({
      title: '请点击右上角分享',
      icon: 'none',
      duration: 2000
    });
  },
  
  /**
   * 🔥 分享给好友（微信小程序生命周期函数）
   * 用户点击右上角"转发"或点击分享按钮时调用
   */
  onShareAppMessage() {
    const { activity } = this.data;
    
    console.log('📤 =============== 分享活动给好友 ===============');
    console.log('📝 活动标题:', activity?.title);
    console.log('🆔 活动ID:', activity?.id);
    
    if (!activity) {
      return {
        title: '精彩活动等你来',
        path: '/pages/main/index'
      };
    }
    
    // 🔥 自定义分享内容
    const shareData = {
      title: `${activity.title} - 快来加入我们吧！`,
      path: `/pages/activity-detail/index?id=${activity.id}`,  // 🔥 分享后打开活动详情页
      imageUrl: activity.images && activity.images.length > 0 ? activity.images[0] : '',  // 🔥 使用活动图片作为分享图
    };
    
    console.log('✅ 分享内容:', shareData);
    
    return shareData;
  },
  
  /**
   * 🔥 分享到朋友圈（微信小程序生命周期函数）
   * 用户点击右上角"分享到朋友圈"时调用
   */
  onShareTimeline() {
    const { activity } = this.data;
    
    console.log('📤 =============== 分享活动到朋友圈 ===============');
    console.log('📝 活动标题:', activity?.title);
    console.log('🆔 活动ID:', activity?.id);
    
    if (!activity) {
      return {
        title: '精彩活动等你来'
      };
    }
    
    // 🔥 自定义分享内容
    const shareData = {
      title: `${activity.title} - ${activity.location}`,  // 🔥 朋友圈分享标题
      query: `id=${activity.id}`,  // 🔥 分享后打开活动详情页的参数
      imageUrl: activity.images && activity.images.length > 0 ? activity.images[0] : ''  // 🔥 使用活动图片作为分享图
    };
    
    console.log('✅ 朋友圈分享内容:', shareData);
    
    return shareData;
  },

  // 🔥 我要加入（添加实名认证检查）
  onJoin() {
    const { activity, joining } = this.data;
    
    // 🔥 防止重复点击
    if (joining) {
      console.log('⚠️ 正在加入活动，请勿重复点击');
      return;
    }
    
    // 🔥 检查是否登录（使用 storage 工具类读取）
    const userInfo = storage.getUserInfo();
    console.log('🔍 检查登录状态，用户信息:', userInfo);
    
    if (!userInfo || !userInfo.userid) {
      console.log('❌ 未登录，跳转到登录页');
      wx.showToast({
        title: '请先登录',
        icon: 'none',
        duration: 2000
      });
      
      // 延迟跳转到登录页
      setTimeout(() => {
        wx.navigateTo({
          url: '/pages/login/index'
        });
      }, 2000);
      return;
    }
    
    console.log('✅ 已登录，用户ID:', userInfo.userid);
    
    // 🔥 检查实名认证状态
    if (!this.checkRealNameAuthForJoin(userInfo)) {
      return; // 如果未实名认证，终止加入流程
    }
    
    // 🔥 实名认证通过，显示加入确认
    wx.showModal({
      title: '确认加入',
      content: `确定要加入"${activity.title}"吗？`,
      success: (res) => {
        if (res.confirm) {
          this.handleJoinActivity(activity.id, userInfo.userid);
        }
      }
    });
  },

  // 🔥 检查实名认证状态（用于加入活动）
  checkRealNameAuthForJoin(userInfo) {
    console.log('🔍 检查实名认证状态（加入活动）...');
    
    if (!userInfo) {
      console.log('❌ 用户信息不存在');
      return false;
    }
    
    // 检查是否已实名认证
    const realNameAuth = userInfo.extraData?.realNameAuth;
    const isVerified = realNameAuth?.verified === true;
    
    console.log('📋 实名认证状态:', {
      hasRealNameAuth: !!realNameAuth,
      verified: isVerified,
      name: realNameAuth?.name || '未设置'
    });
    
    if (!isVerified) {
      console.log('⚠️ 用户未实名认证，需要先完成实名认证');
      wx.showModal({
        title: '实名认证提示',
        content: '加入活动需要先完成实名认证，是否前往认证？',
        confirmText: '去认证',
        cancelText: '取消',
        confirmColor: '#D84545',
        success: (res) => {
          if (res.confirm) {
            console.log('✅ 用户确认前往实名认证');
            wx.navigateTo({
              url: '/pages/verify/index'
            });
          } else {
            console.log('❌ 用户取消实名认证');
          }
        }
      });
      return false;
    }
    
    console.log('✅ 实名认证检查通过');
    return true;
  },
  
  // 🔥 处理加入活动
  handleJoinActivity(activityId, userId) {
    console.log('🎯 =============== 开始加入活动 ===============');
    console.log('📝 活动ID:', activityId);
    console.log('👤 用户ID:', userId);
    
    // 🔥 设置加入中状态，防止重复点击
    this.setData({ joining: true });
    
    // 调用加入活动API
    api.joinActivity(activityId, userId, '待审核')
      .then(response => {
        console.log('✅ 加入活动成功:', response);
        
        if (response.status === 'success') {
          wx.showToast({
            title: response.message || '加入成功，等待审核',
            icon: 'success',
            duration: 2000
          });
          
          // 🔥 更新按钮状态（显示已申请）
          this.setData({
            'activity.joined': true,
            joining: false
          });
        } else {
          // 处理特殊情况（如已经参加）
          if (response.message && (response.message.includes('已参加') || response.message.includes('重复参加'))) {
            wx.showToast({
              title: response.message,
              icon: 'none',
              duration: 2000
            });
            
            // 更新按钮状态
            this.setData({
              'activity.joined': true,
              joining: false
            });
          } else {
            wx.showToast({
              title: response.message || '加入失败',
              icon: 'none',
              duration: 2000
            });
            
            // 🔥 恢复状态
            this.setData({ joining: false });
          }
        }
      })
      .catch(error => {
        console.error('❌ 加入活动失败:', error);
        
        // 🔥 检查错误信息，判断是否是"已参加"的情况
        const errorMsg = error.message || error.msg || '';
        
        if (errorMsg.includes('已参加') || errorMsg.includes('重复参加')) {
          // 🔥 用户已经参加过了，显示友好提示
          wx.showModal({
            title: '提示',
            content: '您已经申请加入过这个活动了，请耐心等待发布者审核',
            showCancel: false,
            confirmText: '知道了',
            confirmColor: '#D84545',
            success: () => {
              // 更新按钮状态
              this.setData({
                'activity.joined': true,
                joining: false
              });
            }
          });
        } else {
          // 其他错误
          wx.showToast({
            title: errorMsg || '加入失败，请重试',
            icon: 'none',
            duration: 2000
          });
          
          // 🔥 恢复状态
          this.setData({ joining: false });
        }
      });
  },

  // 重新加载
  onRetry() {
    if (this.data.activityId) {
      this.loadActivityDetail(this.data.activityId);
    }
  },


  /**
   * 🖼️ 图片加载失败处理
   */
  onDetailImageError(e) {
    const imageIndex = e.currentTarget.dataset.imageIndex;
    console.warn('⚠️ 活动详情图片加载失败');
    console.warn('   图片索引:', imageIndex);
    
    // 不设置默认图片，让微信显示默认的图片加载失败状态
    // 这样可以避免不存在的默认图片导致的连环错误
  }
});
